home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 18 / CU Amiga Magazine's Super CD-ROM 18 (1997)(EMAP Images)(GB)[!][issue 1998-01].iso / CUCD / Online / SANA2Meter / Source / gui.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-04  |  18.9 KB  |  629 lines
  1. /*
  2. ** $VER: gui.c 1.1 (04 Jun 1996)
  3. **
  4. ** (C) Copyright 1996 Marius Gröger
  5. **     All Rights Reserved
  6. **
  7. ** $HISTORY:
  8. **
  9. ** 04 Jun 1996 : 001.001 :  sometimes a GUI group wouldn't be closed
  10. ** 25 Apr 1996 : 001.000 :  created
  11. */
  12.  
  13. #define DEBUG 0
  14.  
  15. /*F*/ /* includes */
  16.  
  17. #include <clib/alib_protos.h>
  18. #include <clib/utility_protos.h>
  19. #include <pragmas/utility_pragmas.h>
  20. #include <clib/exec_protos.h>
  21. #include <pragmas/exec_sysbase_pragmas.h>
  22. #include <clib/dos_protos.h>
  23. #include <pragmas/dos_pragmas.h>
  24. #include <clib/intuition_protos.h>
  25. #include <pragmas/intuition_pragmas.h>
  26. #include <clib/gadtools_protos.h>
  27. #include <pragmas/gadtools_pragmas.h>
  28. #include <clib/icon_protos.h>
  29. #include <pragmas/icon_pragmas.h>
  30. #include <clib/locale_protos.h>
  31. #include <pragmas/locale_pragmas.h>
  32. #include <gtlayout/gtlayout.h>
  33. #include <exec/libraries.h>
  34. #include <exec/devices.h>
  35. #include <exec/memory.h>
  36. #include <exec/io.h>
  37. #include <workbench/startup.h>
  38. #include <utility/tagitem.h>
  39. #define AsmPools
  40. #include <pools/pool_lib.h>
  41.  
  42. #if (USE_EXTREADARGS != 0)
  43. #include <extrdargs.h>
  44. #endif
  45.  
  46. #include "compiler.h"
  47. #include "debug.h"
  48. #define CATCOMP_NUMBERS
  49. #include "locale.h"
  50. #include "sana2meter.h"
  51. #include "constdata.h"
  52.  
  53. #include <strings.h>
  54. #include <stddef.h>
  55. /*E*/
  56.  
  57. /*F*/ /* private symbols */
  58. /*E*/
  59. /*F*/ /* exported symbols */
  60. PUBLIC BOOL preparemenu(GD gd);
  61. PUBLIC VOID checkmenu(GD gd);
  62. PUBLIC VOID updategui(GD gd, BOOL complete);
  63. PUBLIC VOID closegui(GD gd);
  64. PUBLIC BOOL opengui(GD gd);
  65. PUBLIC BOOL dowindow(GD gd, DoWindowCtrl *ctrl);
  66. /*E*/
  67. /*F*/ /* imported symbols */
  68. IMPORT ASM STRPTR GetString(REG(a0) struct LocaleInfo *li, REG(d0) LONG stringNum);
  69. IMPORT VOID saveconfig(GD gd);
  70. IMPORT VOID message(GD gd, LONG title, LONG body, LONG button, ...);
  71. IMPORT VOID *allocpvec(GD gd, ULONG len);
  72. IMPORT VOID freepvec(GD gd, VOID *mem);
  73. IMPORT VOID *allocppvec(GD gd, ULONG len);
  74. IMPORT VOID freeppvec(GD gd, VOID *mem);
  75. /*E*/
  76.  
  77. /*F*/ /* intervals */
  78. PUBLIC const ULONG intervals[] =
  79. {
  80.    {  1 },
  81.    {  2 },
  82.    {  3 },
  83.    {  4 },
  84.    {  5 },
  85.    { 10 },
  86.    { 20 },
  87.    { 30 },
  88.    { 40 },
  89.    { 50 },
  90.    { 60 }
  91. };
  92. /*E*/
  93. /*F*/ /* aging values */
  94. PUBLIC const ULONG agings[] =
  95. {
  96.    {  0 },
  97.    { 10 },
  98.    { 20 },
  99.    { 30 },
  100.    { 40 },
  101.    { 50 }
  102. };
  103. /*E*/
  104. /*F*/ /* menu data structures */
  105. PRIVATE const struct NewMenu menu[] =
  106. {
  107.    NM_TITLE, (STRPTR)MENU_PROJECT,          NULL, 0,                      0, NULL,
  108.    NM_ITEM,  (STRPTR)MENU_SAVECONFIG,       NULL, 0,                      0, NULL,
  109.    NM_ITEM,  (STRPTR)NM_BARLABEL,           NULL, 0,                      0, NULL,
  110.    NM_ITEM,  (STRPTR)MENU_ABOUT,            NULL, 0,                      0, NULL,
  111.    NM_ITEM,  (STRPTR)NM_BARLABEL,           NULL, 0,                      0, NULL,
  112.    NM_ITEM,  (STRPTR)MENU_QUIT,             NULL, 0,                      0, NULL,
  113.    NM_TITLE, (STRPTR)MENU_SETTINGS,         NULL, 0,                      0, NULL,
  114.    NM_ITEM,  (STRPTR)MENU_UPDATE,           NULL, 0,                      0, NULL,
  115.    NM_SUB,   (STRPTR)MENU_REFRESH1,         NULL, CHECKIT,               ~1, NULL,
  116.    NM_SUB,   (STRPTR)MENU_REFRESH2,         NULL, CHECKIT,               ~2, NULL,
  117.    NM_SUB,   (STRPTR)MENU_REFRESH3,         NULL, CHECKIT,               ~4, NULL,
  118.    NM_SUB,   (STRPTR)MENU_REFRESH4,         NULL, CHECKIT,               ~8, NULL,
  119.    NM_SUB,   (STRPTR)MENU_REFRESH5,         NULL, CHECKIT,              ~16, NULL,
  120.    NM_SUB,   (STRPTR)MENU_REFRESH10,        NULL, CHECKIT,              ~32, NULL,
  121.    NM_SUB,   (STRPTR)MENU_REFRESH20,        NULL, CHECKIT,              ~64, NULL,
  122.    NM_SUB,   (STRPTR)MENU_REFRESH30,        NULL, CHECKIT,             ~128, NULL,
  123.    NM_SUB,   (STRPTR)MENU_REFRESH40,        NULL, CHECKIT,             ~256, NULL,
  124.    NM_SUB,   (STRPTR)MENU_REFRESH50,        NULL, CHECKIT,             ~512, NULL,
  125.    NM_SUB,   (STRPTR)MENU_REFRESH60,        NULL, CHECKIT,            ~1024, NULL,
  126.    NM_ITEM,  (STRPTR)MENU_CPSAGING,         NULL, 0,                      0, NULL,
  127.    NM_SUB,   (STRPTR)MENU_AGING0,           NULL, CHECKIT,               ~1, NULL,
  128.    NM_SUB,   (STRPTR)MENU_AGING10,          NULL, CHECKIT,               ~2, NULL,
  129.    NM_SUB,   (STRPTR)MENU_AGING20,          NULL, CHECKIT,               ~4, NULL,
  130.    NM_SUB,   (STRPTR)MENU_AGING30,          NULL, CHECKIT,               ~8, NULL,
  131.    NM_SUB,   (STRPTR)MENU_AGING40,          NULL, CHECKIT,              ~16, NULL,
  132.    NM_SUB,   (STRPTR)MENU_AGING50,          NULL, CHECKIT,              ~32, NULL,
  133.    NM_ITEM,  (STRPTR)NM_BARLABEL,           NULL, 0,                      0, NULL,
  134.    NM_ITEM,  (STRPTR)MENU_JUMP,             NULL, 0,                      0, NULL,
  135.    NM_ITEM,  (STRPTR)NM_BARLABEL,           NULL, 0,                      0, NULL,
  136.    NM_ITEM,  (STRPTR)MENU_STAYFRONT,        NULL, CHECKIT|MENUTOGGLE,     0, NULL,
  137.    NM_ITEM,  (STRPTR)NM_BARLABEL,           NULL, 0,                      0, NULL,
  138.    NM_END
  139. };
  140.  
  141. #define FIRST_REFRESH_ITEM 8
  142.  
  143. #define FIRST_AGING_ITEM 20
  144.  
  145. #define STAYFRONT_ITEM 29
  146.  
  147. /*E*/
  148.  
  149. /*F*/ PUBLIC BOOL dowindow(GD gd, DoWindowCtrl *ctrl)
  150. {
  151.    struct IntuiMessage *im;
  152.    ULONG qualifier;
  153.    ULONG class;
  154.    UWORD code;
  155.    struct Gadget *gadget;
  156.    BOOL running = TRUE;
  157.    PD pd = gd->gd_Public;
  158.  
  159.    *ctrl = DOWCTRL_NOP;
  160.  
  161.    while(im = GT_GetIMsg(gd->gd_Handle->Window->UserPort))
  162.    {
  163.       class     = im->Class;
  164.       code      = im->Code;
  165.       qualifier = im->Qualifier;
  166.       gadget    = im->IAddress;
  167.  
  168.       GT_ReplyIMsg(im);
  169.  
  170.       LT_HandleInput(gd->gd_Handle, qualifier, &class, &code, &gadget);
  171.  
  172.       switch(class)
  173.       {
  174.          case IDCMP_CLOSEWINDOW:
  175.              running = FALSE;
  176.          break;
  177.  
  178.          case IDCMP_MENUPICK:
  179.          {
  180.             UWORD n_menu, n_item, n_subitem;
  181.             struct MenuItem *it;
  182.  
  183.             while(it = ItemAddress(gd->gd_Menu, code))
  184.             {
  185.                n_menu = MENUNUM(code);
  186.                n_item = ITEMNUM(code);
  187.                n_subitem = SUBNUM(code);
  188.  
  189.                if (n_menu == 0)
  190.                {
  191.                   if (n_item == 0)
  192.                      saveconfig(gd);
  193.                   else
  194.                   if (n_item == 2)
  195.                   {
  196.                      message(gd, REQ_ABOUT_TITLE, REQ_ABOUT_BODY, REQ_ABOUT_BUTTON,
  197.                         VERSION, REVISION, CPUTXT, EMAIL_AUTHOR);
  198.                   }
  199.                   else
  200.                   if (n_item == 4)
  201.                      running = FALSE;
  202.                }
  203.                else if (n_menu == 1)
  204.                {
  205.                   if (n_item == 0)
  206.                   {
  207.                      gd->gd_Refresh = gd->gd_time.tv_secs = intervals[n_subitem];
  208.                      AbortIO((struct IORequest*)&pd->pd_TReq);
  209.                   }
  210.                   else
  211.                   if (n_item == 1)
  212.                   {
  213.                      gd->gd_CPSAging = agings[n_subitem];
  214.                      gd->gd_CPSAgingComp = 100 - gd->gd_CPSAging;
  215.                   }
  216.                   else
  217.                   if (n_item == 3)
  218.                   {
  219.                      if (NextPubScreen(gd->gd_Handle->Screen, gd->gd_Public->pd_Pubscreen))
  220.                         *ctrl = DOWCTRL_REOPEN | DOWCTRL_SHOWWINDOW;
  221.                   }
  222.                   else
  223.                   if (n_item == 5)
  224.                   {
  225.                      if ((gd->gd_StayFront = ((it->Flags & CHECKED) != 0)))
  226.                         WindowToFront(gd->gd_Handle->Window);
  227.                   }
  228.                   else
  229.                   if (n_item >= 7)
  230.                   {
  231.                      struct GlobalDevData *gdd;
  232.  
  233.                      if (gdd = (struct GlobalDevData *)GTMENUITEM_USERDATA(it))
  234.                      {
  235.                         gdd->gd_Active = ((it->Flags & CHECKED) != 0);
  236.                         *ctrl = DOWCTRL_UPDATE;
  237.                      }
  238.                   }
  239.                }
  240.                else if (n_menu >= 2)
  241.                {
  242.                   struct Watch *w;
  243.  
  244.                   if (w = (struct Watch *)GTMENUITEM_USERDATA(it))
  245.                   {
  246.                      if (it->Flags & CHECKED)
  247.                         w->w_Flags |= WF_ACTIVE;
  248.                      else
  249.                         w->w_Flags &= ~WF_ACTIVE;
  250.                      *ctrl = DOWCTRL_UPDATE;
  251.                   }
  252.                }
  253.                code = it->NextSelect;
  254.             }
  255.          }
  256.          break;
  257.  
  258.          case IDCMP_GADGETUP:
  259.          break;
  260.       }
  261.    }
  262.  
  263.    return running;
  264. }
  265. /*E*/
  266.  
  267. /*F*/ PUBLIC BOOL preparemenu(GD gd)
  268. {
  269.    struct NewMenu *nm;
  270.    struct Watch *w;
  271.    ULONG i, ss;
  272.    BOOL rc = TRUE;
  273.    struct GlobalDevData *gdd;
  274.    WORD extraitems;
  275.  
  276.    /* calculate the number of additional menu items for display control */
  277.    extraitems = 0;
  278.  
  279.    /* device selection */
  280.    extraitems += gd->gd_NumDevices;
  281.  
  282.    SCANDEVS(gdd, &gd->gd_Devices)
  283.    {
  284.       /* Menu Title */
  285.       extraitems += 1;
  286.       /* Std. DeviceQuery+Stats */
  287.       extraitems += NUM_STDWATCHES;
  288.       /* SpecialStats */
  289.       extraitems += gdd->gd_ValidSpecialStats;
  290.       /* Type-Tracking */
  291.       extraitems += gdd->gd_NumTT * (NUM_TTWATCHES + 1);
  292.    }
  293.  
  294.    if (gd->gd_NewMenu = allocpvec(gd, sizeof(menu) + extraitems*sizeof(struct NewMenu)))
  295.    {
  296.       CopyMem((void*)menu, (void*)gd->gd_NewMenu, sizeof(menu));
  297.  
  298.       for (nm = gd->gd_NewMenu; nm->nm_Type != NM_END; ++nm)
  299.       {
  300.          STRPTR p;
  301.  
  302.          if ((nm->nm_Label != NM_BARLABEL) && !(menu->nm_Type & NM_IGNORE))
  303.          {
  304.             p = GetString(&gd->gd_LocaleInfo, (LONG)nm->nm_Label);
  305.             if (p[1] == '\0')
  306.             {
  307.                nm->nm_CommKey = p;
  308.                nm->nm_Label = p+2;
  309.             }
  310.             else
  311.                nm->nm_Label = p;
  312.          }
  313.       }
  314.  
  315.       gd->gd_DevSelStart = nm;
  316.  
  317.       SCANDEVS(gdd, &gd->gd_Devices)
  318.       {
  319.          nm->nm_Type = NM_ITEM;
  320.          nm->nm_UserData = (APTR)gdd;
  321.          nm->nm_Label = gdd->gd_Title;
  322.          nm->nm_Flags = CHECKIT|MENUTOGGLE;
  323.          nm->nm_CommKey = NULL;
  324.          ++nm;
  325.       }
  326.  
  327.       gd->gd_WatchStart = nm;
  328.  
  329.       SCANDEVS(gdd, &gd->gd_Devices)
  330.       {
  331.          /* Menu Title */
  332.          nm->nm_Type = NM_TITLE;
  333.          nm->nm_Label = gdd->gd_Title;
  334.          ++nm;
  335.  
  336.          /* Std. DeviceQuery+Stats */
  337.          for (i=0, w = gdd->gd_StdWatches; i<NUM_STDWATCHES; ++nm, ++i, ++w)
  338.          {
  339.             nm->nm_Type = NM_ITEM;
  340.             nm->nm_UserData = (APTR)w;
  341.             nm->nm_Label = w->w_Label;
  342.             nm->nm_Flags = CHECKIT|MENUTOGGLE;
  343.             nm->nm_CommKey = NULL;
  344.          }
  345.          /* SpecialStats */
  346.          for(ss = gdd->gd_ValidSpecialStats; ss; --ss, ++nm, ++w)
  347.          {
  348.             nm->nm_Type = NM_ITEM;
  349.             nm->nm_UserData = (APTR)w;
  350.             nm->nm_Label = w->w_Label;
  351.             nm->nm_Flags = CHECKIT|MENUTOGGLE;
  352.             nm->nm_CommKey = NULL;
  353.          }
  354.  
  355.          /* Type-Tracking */
  356.          for (w=gdd->gd_TrackWatches; w->w_Link.mln_Succ; w=(struct Watch*)w->w_Link.mln_Succ, ++nm)
  357.          {
  358.             if (w->w_Flags & WF_FIRSTTT)
  359.             {
  360.                nm->nm_Type = NM_ITEM;
  361.                nm->nm_Label = w->w_TrackType->tt_Label;
  362.                nm->nm_CommKey = NULL;
  363.                nm->nm_Flags = 0;
  364.                nm->nm_UserData = NULL;
  365.                ++nm;
  366.             }
  367.             nm->nm_Type = NM_SUB;
  368.             nm->nm_Label = w->w_Label;
  369.             nm->nm_CommKey = NULL;
  370.             nm->nm_Flags = CHECKIT|MENUTOGGLE;
  371.             nm->nm_UserData = (APTR)w;
  372.          }
  373.       }
  374.       nm->nm_Type = NM_END;
  375.    }
  376.    else rc = TRUE;
  377.  
  378.    return rc;
  379. }
  380. /*E*/
  381. /*F*/PUBLIC VOID checkmenu(GD gd)
  382. {
  383.    struct NewMenu *nm;
  384.    struct Watch *w;
  385.    struct GlobalDevData *gdd;
  386.    int i;
  387.  
  388.    for (i=0, nm = gd->gd_NewMenu + FIRST_REFRESH_ITEM; i<NUM_REFRESHS; ++nm, ++i)
  389.    {
  390.       if (intervals[i] == gd->gd_Refresh)
  391.          nm->nm_Flags |= CHECKED;
  392.       else
  393.          nm->nm_Flags &= ~CHECKED;
  394.    }
  395.  
  396.    for (i=0, nm = gd->gd_NewMenu + FIRST_AGING_ITEM; i<NUM_AGINGS; ++nm, ++i)
  397.    {
  398.       if (agings[i] == gd->gd_CPSAging)
  399.          nm->nm_Flags |= CHECKED;
  400.       else
  401.          nm->nm_Flags &= ~CHECKED;
  402.    }
  403.  
  404.    nm = gd->gd_NewMenu + STAYFRONT_ITEM;
  405.    if (gd->gd_StayFront)
  406.       nm->nm_Flags |= CHECKED;
  407.    else
  408.       nm->nm_Flags &= ~CHECKED;
  409.  
  410.    for (i=gd->gd_NumDevices, nm = gd->gd_DevSelStart; i; ++nm, --i)
  411.    {
  412.       if (gdd = (struct GlobalDevData*)nm->nm_UserData)
  413.       {
  414.          if (gdd->gd_Active)
  415.             nm->nm_Flags |= CHECKED;
  416.          else
  417.             nm->nm_Flags &= ~CHECKED;
  418.       }
  419.    }
  420.  
  421.    for (nm = gd->gd_WatchStart; nm->nm_Type != NM_END; ++nm)
  422.    {
  423.       if (w = (struct Watch*)nm->nm_UserData)
  424.       {
  425.          if (w->w_Flags & WF_OFF)
  426.             nm->nm_Flags |= NM_ITEMDISABLED;
  427.  
  428.          if (w->w_Flags & WF_ACTIVE)
  429.             nm->nm_Flags |= CHECKED;
  430.          else
  431.             nm->nm_Flags &= ~CHECKED;
  432.       }
  433.    }
  434.    return ;
  435. }
  436. /*E*/
  437.  
  438. /*F*/ PUBLIC VOID updategui(GD gd, BOOL complete)
  439. {
  440.    struct GlobalDevData *gdd;
  441.    struct Watch *w;
  442.  
  443.    if (complete)
  444.    {
  445.       SCANDEVS(gdd, &gd->gd_Devices)
  446.       {
  447.          SCANWATCHES(w, &gdd->gd_Watches)
  448.          {
  449.             if (w->w_Flags & WF_ACTIVE)
  450.             {
  451.                LT_SetAttributes(gd->gd_Handle, w->w_ID,
  452.                                        GTNM_Number, *(w->w_Value),
  453.                                        TAG_DONE);
  454.             }
  455.          }
  456.       }
  457.    }
  458.    else
  459.    {
  460.       SCANDEVS(gdd, &gd->gd_Devices)
  461.       {
  462.          SCANWATCHES(w, &gdd->gd_Watches)
  463.          {
  464.             if ((w->w_Flags & (WF_ACTIVE | WF_STATIC)) == WF_ACTIVE)
  465.             {
  466.                LT_SetAttributes(gd->gd_Handle, w->w_ID,
  467.                                        GTNM_Number, *(w->w_Value),
  468.                                        TAG_DONE);
  469.             }
  470.          }
  471.       }
  472.    }
  473.  
  474.    if (gd->gd_StayFront)
  475.       WindowToFront(gd->gd_Handle->Window);
  476.  
  477.    return ;
  478. }
  479. /*E*/
  480. /*F*/PUBLIC VOID closegui(GD gd)
  481. {
  482.    if (gd->gd_Handle)
  483.    {
  484.       gd->gd_Left = gd->gd_Handle->Window->LeftEdge;
  485.       gd->gd_Top = gd->gd_Handle->Window->TopEdge;
  486.  
  487.       LT_DeleteHandle(gd->gd_Handle);
  488.       gd->gd_Handle = NULL;
  489.    }
  490.    if (gd->gd_Menu)
  491.    {
  492.       LT_DisposeMenu(gd->gd_Menu);
  493.       gd->gd_Menu = NULL;
  494.    }
  495.    return ;
  496. }
  497. /*E*/
  498. /*F*/ PUBLIC BOOL opengui(GD gd)
  499. {
  500.    struct GlobalDevData *gdd;
  501.    struct PublicData *pd = gd->gd_Public;
  502.    BOOL rc = FALSE, vgroup;
  503.    int i;
  504.    struct Watch *w;
  505.    STRPTR windowtitle = "SANA2Meter";
  506.    LONG error;
  507.  
  508.    if (gd->gd_Handle = LT_CreateHandleTags(NULL,
  509.                                  LH_AutoActivate,FALSE,
  510.                                  LH_UserData, gd,
  511.                                  LAHN_MenuGlyphs, TRUE,
  512.                                  gd->gd_CustomFont ? LH_Font : TAG_IGNORE, &pd->pd_Font,
  513.                                  pd->pd_Pubscreen[0] ? LAHN_PubScreenName : TAG_IGNORE, pd->pd_Pubscreen,
  514.                                  TAG_DONE))
  515.    {
  516.       i = 0;
  517.       LT_New(gd->gd_Handle, LA_Type, HORIZONTAL_KIND, TAG_DONE);
  518.       if (gd->gd_NumActives == 0)
  519.       {
  520.          LT_New(gd->gd_Handle, LA_Type, TEXT_KIND,
  521.                         GTTX_Text, GetString(&gd->gd_LocaleInfo, TXT_INACTIVE),
  522.                         TAG_DONE);
  523.       }
  524.       else
  525.       {
  526.          SCANDEVS(gdd, &gd->gd_Devices)
  527.          {
  528.             if (gdd->gd_Active)
  529.             {
  530.                if (gd->gd_NumActives == 1) windowtitle = gdd->gd_Title;
  531.                vgroup = FALSE;
  532.                LT_New(gd->gd_Handle, LA_Type, VERTICAL_KIND,
  533.                                      (gd->gd_NumActives > 1) ?
  534.                                              LA_LabelText : TAG_IGNORE, gdd->gd_Title,
  535.                                      TAG_DONE);
  536.                SCANWATCHES(w, &gdd->gd_Watches)
  537.                {
  538.                   if ((w->w_Flags & WF_FIRSTTT) && (w->w_TrackType->tt_Flags & TTF_ACTIVE))
  539.                   {
  540.                      if (vgroup) {
  541.                         LT_EndGroup(gd->gd_Handle);
  542.                      }
  543.                      LT_New(gd->gd_Handle, LA_Type, VERTICAL_KIND, LA_LabelText, w->w_TrackType->tt_Label, TAG_DONE);
  544.                      vgroup = TRUE;
  545.                   }
  546.  
  547.                   if (w->w_Flags & WF_ACTIVE)
  548.                   {
  549.                      if (!vgroup)
  550.                      {
  551.                         vgroup = TRUE;
  552.                         LT_New(gd->gd_Handle, LA_Type, VERTICAL_KIND, TAG_DONE);
  553.                      }
  554.                      LT_New(gd->gd_Handle, LA_Type, NUMBER_KIND,
  555.                                            LA_LabelText, w->w_Label,
  556.                                            /*w->w_Format ? GTNM_Format : TAG_IGNORE, w->w_Format,*/
  557.                                            LA_ID, w->w_ID = ++i,
  558.                                            LA_NoKey, TRUE,
  559.                                            LA_Chars, 9,
  560.                                            w->w_Value ? GTNM_Number : TAG_IGNORE, *(w->w_Value),
  561.                                            LA_ExtraSpace, -1,
  562.                                            (GadToolsBase->lib_Version == 39) ?
  563.                                                 TAG_IGNORE : GTNM_Justification, GTJ_RIGHT,
  564.                                            TAG_DONE);
  565.                   }
  566.                }
  567.                if (vgroup) {
  568.                   LT_EndGroup(gd->gd_Handle);
  569.                }
  570.                LT_EndGroup(gd->gd_Handle);
  571.             }
  572.          }
  573.       }
  574.       LT_EndGroup(gd->gd_Handle);
  575.  
  576.       checkmenu(gd);
  577.       if (gd->gd_Menu = LT_NewMenuTemplate(gd->gd_Handle->Screen, NULL,
  578.                                            gd->gd_Handle->AmigaGlyph,
  579.                                            gd->gd_Handle->CheckGlyph,
  580.                                            &error, gd->gd_NewMenu))
  581.       {
  582.          if (LT_Build(gd->gd_Handle, LAWN_Title,        windowtitle,
  583.                                      LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  584.                                      LAWN_SmartZoom,    TRUE,
  585.                                      LAWN_Menu,         gd->gd_Menu,
  586.                                      LAWN_Left,         gd->gd_Left,
  587.                                      LAWN_Top,          gd->gd_Top,
  588.                                      WA_Activate,       gd->gd_Inactive ? FALSE : TRUE,
  589.                                      WA_DepthGadget,    TRUE,
  590.                                      WA_DragBar,        TRUE,
  591.                                      WA_CloseGadget,    TRUE,
  592.                                      TAG_DONE))
  593.          {
  594.             ULONG pen = gd->gd_Handle->DrawInfo->dri_Pens[HIGHLIGHTTEXTPEN];
  595.  
  596.             if (gd->gd_ToBack)
  597.             {
  598.                WindowToBack(gd->gd_Handle->Window);
  599.                gd->gd_ToBack = 0;
  600.             }
  601.             gd->gd_Inactive = 0;
  602.  
  603.             if (gd->gd_NumActives != 0)
  604.             {
  605.                SCANDEVS(gdd, &gd->gd_Devices)
  606.                {
  607.                   SCANWATCHES(w, &gdd->gd_Watches)
  608.                   {
  609.                      if (w->w_Flags & WF_ACTIVE)
  610.                         LT_SetAttributes(gd->gd_Handle, w->w_ID, GTNM_FrontPen, pen, TAG_DONE);
  611.                   }
  612.                }
  613.             }
  614.             rc = TRUE;
  615.          }
  616.          else message(gd, REQ_ERROR_TITLE, REQ_ERROR_NOGUI, REQ_ERROR_QUITBUTTON);
  617.       }
  618.       else
  619.       {
  620.          message(gd, REQ_ERROR_TITLE, REQ_ERROR_NOGUI, REQ_ERROR_QUITBUTTON);
  621.       }
  622.    }
  623.    else message(gd, REQ_ERROR_TITLE, REQ_ERROR_NOGUI, REQ_ERROR_QUITBUTTON);
  624.  
  625.    return rc;
  626. }
  627. /*E*/
  628.  
  629.